#include <mips/regdef.h>
#include <sys/syscall.h>

#define BSIZE			(3)

	.text
	.align 	2
	.global main
	.ent 	main

main:
	.frame	$fp, 56, ra

	.set noreorder
	.cpload	t9
	.set reorder

	subu	sp,sp,56

	# Guardo los registros
	.cprestore 40
	sw		ra,48(sp)
	sw		$fp,44(sp)
	move	$fp,sp

	sw		zero, 20($fp)	// tamanio del buffer
	
	# malloc del buffer lectura
	li		a0,	1
	jal 	mymalloc
	sw      v0, 24($fp) // buffer auxiliar
	lw		t1,	24($fp)
	sb		zero, 0(t1)	// inicializo
		
	li		a0,	BSIZE
	jal 	mymalloc
	sw      v0, 16($fp) // buffer auxiliar

while_loop:

	# antes de leer borro el buffer
	li		t1, 0		// i
	lw		t2, 16($fp) // ptr a buffer origen
	li		t3,	BSIZE // length del origen
loop_ini:
	beq	t1, t4, lectura
	sb	zero, 0(t2)
	addiu t1, t1, 1
	addiu t2, t2, 1
	j	loop_ini

lectura:	

	# Leo de STDIN
	li		v0,	SYS_read
	li		a0,	0
	lw		a1,	16($fp)	// puntero de lectura
	li		a2,	BSIZE		// leo un byte
	syscall

	bne	a3,zero,read_error

	# termina cuando no hay nada mas para leer
	beq	v0, zero, eof

	# malloc del buffer auxiliar con un espacio de mas
	lw		a0, 24($fp)
	jal	length
	sw      v0, 20($fp)
	lw		a0, 16($fp)
	jal	length
	sw	v0, 32($fp)
	
	lw		t1, 20($fp)
	lw		t2, 32($fp)	
	addu	t3, t2, t1
	addiu	t3, t3, 1

	move	a0, t3
	jal 	mymalloc
	sw      v0, 28($fp) // buffer auxiliar
	
	# copio los n chars de origen a destino
	li		t1, 0
	lw		t2, 24($fp) // ptr a buffer origen
	lw		t3, 28($fp) // ptr a buffer destino
	lw		t4,	20($fp) // length del origen

loop_copia:
	beq	t1, t4, fin_copiado
	lb	t6,	0(t2)
	sb	t6, 0(t3)
	addiu	t1, t1, 1 // i++
	addiu	t2, t2, 1
	addiu	t3, t3, 1
	
	sb	zero, 0(t3)	// fin linea
	
	j 	loop_copia

fin_copiado:
	# copio los n chars de origen a destino
	li		t1, 0
	lw		t2, 16($fp) // ptr a buffer origen
	lw		t3, 28($fp) // ptr a buffer destino
	lw		a0, 28($fp)
	jal	length
	addu	t3, t3, v0
	lw		t4,	32($fp) // length del origen

loop_copia_2:
	beq	t1, t4, fin_copia
	lb	t6,	0(t2)
	sb	t6, 0(t3)
	addiu	t1, t1, 1 // i++
	addiu	t2, t2, 1
	addiu	t3, t3, 1
	
	sb	zero, 0(t3)	// fin linea
	
	j 	loop_copia_2
	
fin_copia:
	# free del buffer origen
	lw		a0,	24($fp)
	jal 	myfree
	
	# intercambio los punteros
	lw		t3, 28($fp)
	sw		t3, 24($fp)
	j 	while_loop

eof:

	lw		a0, 24($fp)
	jal	length
	sw      v0, 28($fp)

	# malloc del buffer resultado
	lw		a0,	28($fp)
	jal 	mymalloc
	sw      v0, 36($fp) // buffer resultado
	
	# llamo a mergesort.
	lw	a0, 24($fp)		// input
	lw	a1, 36($fp)		// resultado
	jal	mergesort
	
	# Imprimo el resultado por pantalla
	li	v0, SYS_write 
	li	a0, 1
	lw	a1, 36($fp)
	lw	a2, 28($fp)
	syscall
	# Imprimo un salto de linea
	li		v0, SYS_write
	li		a0, 1
	la		a1, str_salto
	li		a2, 1
	syscall	
	
	# free del buffer resultado
	lw		a0,	36($fp)
	jal 	myfree		
	
	# free del buffer auxiliar
	lw		a0,	24($fp)
	jal 	myfree
	
	# free del buffer auxiliar
	lw		a0,	16($fp)
	jal 	myfree
	
	j	main_return

read_error:
	################
	li	v0, SYS_write 
	li	a0, 1
	la	a1,	str_error
	li	a2, 6
	syscall	
	################
	################
	li	v0, SYS_write 
	li	a0, 1
	la	a1,	str_salto
	li	a2, 1
	syscall	
	################
		
main_return:
	# destruyo el stack
	move	sp, $fp
	lw	$fp, 44(sp)
	lw	ra,  48(sp)
	addu	sp, sp, 56

	j	ra
	.end	main
	
	.rdata
str_hola: .asciiz	"hola\n"
str_error: .asciiz	"error\n"
str_while: .asciiz	"while\n"
str_salto: .asciiz	"\n"
str_fin: .asciiz	"\0"
str_count: .asciiz	"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
